/**
 * 文件上传相关工具类
 */

/**
 * 检查页面是否有文件正在上传中
 * @param {Element} container 可选，指定容器元素，不传则检查整个页面
 * @returns {boolean} true表示有文件正在上传，false表示没有
 */
export function hasFilesUploading(container = document) {
  const uploadingElements = container.querySelectorAll('.files-uploading')
  return uploadingElements.length > 0
}

/**
 * 获取正在上传的文件数量
 * @param {Element} container 可选，指定容器元素，不传则检查整个页面
 * @returns {number} 正在上传的文件数量
 */
export function getUploadingFilesCount(container = document) {
  const uploadingElements = container.querySelectorAll('.files-uploading')
  return uploadingElements.length
}

/**
 * 检查指定的上传组件是否有文件正在上传
 * @param {Element} uploadComponent 上传组件的DOM元素
 * @returns {boolean} true表示该组件有文件正在上传，false表示没有
 */
export function isComponentUploading(uploadComponent) {
  if (!uploadComponent) return false
  return uploadComponent.classList.contains('files-uploading')
}

/**
 * 等待所有上传完成
 * @param {number} timeout 超时时间，单位毫秒，默认30秒
 * @param {Element} container 可选，指定容器元素，不传则检查整个页面
 * @returns {Promise<boolean>} Promise，resolve时表示所有上传完成，reject表示超时
 */
export function waitForUploadsComplete(timeout = 30000, container = document) {
  return new Promise((resolve, reject) => {
    const startTime = Date.now()
    
    const checkUploads = () => {
      // 检查是否还有文件在上传
      if (!hasFilesUploading(container)) {
        resolve(true)
        return
      }
      
      // 检查是否超时
      if (Date.now() - startTime > timeout) {
        reject(new Error('等待上传完成超时'))
        return
      }
      
      // 继续检查
      setTimeout(checkUploads, 500)
    }
    
    checkUploads()
  })
}

/**
 * 在提交表单前检查是否有文件正在上传
 * @param {Function} callback 检查完成后的回调函数
 * @param {Object} options 配置选项
 * @param {Element} options.container 检查范围的容器元素
 * @param {string} options.message 发现上传中文件时的提示消息
 * @param {boolean} options.showConfirm 是否显示确认对话框
 * @param {Function} options.confirmCallback 确认对话框的回调
 */
export function checkUploadsBeforeSubmit(callback, options = {}) {
  const {
    container = document,
    message = '检测到有文件正在上传中，请等待上传完成后再提交',
    showConfirm = true,
    confirmCallback = null
  } = options
  
  if (hasFilesUploading(container)) {
    if (showConfirm) {
      // 这里可以使用ElementUI的MessageBox或者其他UI库的确认框
      if (window.Vue && window.Vue.prototype.$confirm) {
        window.Vue.prototype.$confirm(
          message + '，是否继续等待？', 
          '提示', 
          {
            confirmButtonText: '等待完成',
            cancelButtonText: '强制提交',
            type: 'warning'
          }
        ).then(() => {
          // 用户选择等待
          waitForUploadsComplete().then(() => {
            callback(true)
          }).catch(() => {
            callback(false, '等待上传完成超时')
          })
        }).catch(() => {
          // 用户选择强制提交
          if (confirmCallback) {
            confirmCallback()
          } else {
            callback(true)
          }
        })
      } else {
        // 降级到原生confirm
        const userChoice = confirm(message + '，是否继续等待？')
        if (userChoice) {
          waitForUploadsComplete().then(() => {
            callback(true)
          }).catch(() => {
            callback(false, '等待上传完成超时')
          })
        } else {
          callback(true)
        }
      }
    } else {
      callback(false, message)
    }
  } else {
    callback(true)
  }
}

/**
 * Vue混入，可以在组件中直接使用上传检查方法
 */
export const uploadCheckMixin = {
  methods: {
    /**
     * 检查页面是否有文件正在上传
     */
    $hasFilesUploading(container) {
      return hasFilesUploading(container)
    },
    
    /**
     * 获取正在上传的文件数量
     */
    $getUploadingFilesCount(container) {
      return getUploadingFilesCount(container)
    },
    
    /**
     * 等待所有上传完成
     */
    $waitForUploadsComplete(timeout, container) {
      return waitForUploadsComplete(timeout, container)
    },
    
    /**
     * 提交前检查上传状态
     */
    $checkUploadsBeforeSubmit(callback, options) {
      return checkUploadsBeforeSubmit(callback, options)
    },
    
    /**
     * 安全提交表单（自动检查上传状态）
     */
    $safeSubmit(submitFunction, options = {}) {
      this.$checkUploadsBeforeSubmit((canSubmit, errorMessage) => {
        if (canSubmit) {
          submitFunction()
        } else if (errorMessage) {
          this.$message.warning(errorMessage)
        }
      }, options)
    }
  }
}

/**
 * 页面级别的上传状态管理器
 */
export class UploadStatusManager {
  constructor() {
    this.observers = []
    this.isObserving = false
  }
  
  /**
   * 开始监听页面上传状态变化
   */
  startObserving() {
    if (this.isObserving) return
    
    this.observer = new MutationObserver((mutations) => {
      mutations.forEach((mutation) => {
        if (mutation.type === 'attributes' && mutation.attributeName === 'class') {
          const target = mutation.target
          if (target.classList.contains('files-uploading')) {
            this.notifyObservers('uploadStart', target)
          } else if (mutation.oldValue && mutation.oldValue.includes('files-uploading')) {
            this.notifyObservers('uploadEnd', target)
          }
        }
      })
    })
    
    this.observer.observe(document.body, {
      attributes: true,
      attributeOldValue: true,
      subtree: true,
      attributeFilter: ['class']
    })
    
    this.isObserving = true
  }
  
  /**
   * 停止监听
   */
  stopObserving() {
    if (this.observer) {
      this.observer.disconnect()
      this.isObserving = false
    }
  }
  
  /**
   * 添加观察者
   */
  addObserver(callback) {
    this.observers.push(callback)
  }
  
  /**
   * 移除观察者
   */
  removeObserver(callback) {
    const index = this.observers.indexOf(callback)
    if (index > -1) {
      this.observers.splice(index, 1)
    }
  }
  
  /**
   * 通知所有观察者
   */
  notifyObservers(event, target) {
    this.observers.forEach(callback => {
      try {
        callback(event, target)
      } catch (error) {
        console.error('Upload status observer error:', error)
      }
    })
  }
}

// 创建全局实例
export const globalUploadManager = new UploadStatusManager()

// 自动启动监听（可选）
if (typeof window !== 'undefined') {
  // 页面加载完成后启动监听
  if (document.readyState === 'loading') {
    document.addEventListener('DOMContentLoaded', () => {
      globalUploadManager.startObserving()
    })
  } else {
    globalUploadManager.startObserving()
  }
}